#include "QClient.h"
#include <QApplication>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <QKeyEvent>
#include <QUdpSocket>
#include <QDataStream>
#include <QDebug>
#include <QDateTime>
#include <QCloseEvent>
#include <QTimer>
#include <QFont>
#include <QCheckBox> // 新增：包含QCheckBox头文件
#include <QMutexLocker> // 新增：包含QMutexLocker头文件
#include <QEventLoop> // 新增：包含QEventLoop头文件
#include <QFile> // 新增：用于QSS样式文件加载
#include <QStyle> // 新增：用于动态样式切换

// QClient 实现
QClient::QClient(QWidget *parent)
    : QMainWindow(parent)
    , m_socket(nullptr)
    , m_serverPort(12345)
    , m_connectionState(ConnectionState::DISCONNECTED)
    , m_reconnectAttempts(0)
    , m_playerId(0)
    , m_debugMode(false)  // 新增：初始化调试模式为关闭
    , m_debugFrame(nullptr)
    , m_collapseButton(nullptr) 
    , m_debugAreaCollapsed(true)  // 默认折叠状态
    , m_collapseAnimation(nullptr)
    , m_longPressTimer(nullptr)
    , m_progressTimer(nullptr)
    , m_reverseTimer(nullptr)
    , m_longPressProgress(0)
    , m_isLongPressing(false)
    , m_isReverseAnimating(false)
    , m_timeoutTimer(nullptr)
    , m_isStartRequestPending(false)
    , m_isAttackRequestPending(false)
{
    setWindowTitle("MUD冒险世界 - 连接中...");
    setMinimumSize(800, 600);
    
    // 初始化长按计时器
    m_longPressTimer = new QTimer(this);
    m_longPressTimer->setSingleShot(true);
    connect(m_longPressTimer, &QTimer::timeout, this, &QClient::executeLongPressAction);
    
    m_progressTimer = new QTimer(this);
    connect(m_progressTimer, &QTimer::timeout, this, &QClient::updateLongPressProgress);
    
    // 初始化反向恢复计时器
    m_reverseTimer = new QTimer(this);
    connect(m_reverseTimer, &QTimer::timeout, this, &QClient::updateReverseProgress);
    
    // 初始化超时保护计时器
    m_timeoutTimer = new QTimer(this);
    m_timeoutTimer->setSingleShot(true);
    connect(m_timeoutTimer, &QTimer::timeout, this, &QClient::resetButtonsOnTimeout);
    
    setupUI();
    loadStyleSheet();
    initializeNetwork();
    
    // 显示启动信息
    addSystemMessage("==============================");
    addSystemMessage("🎮 欢迎来到MUD冒险世界！");
    addSystemMessage("==============================");
    addSystemMessage("🔗 正在连接服务器...");
    
    // 自动连接服务器
    QTimer::singleShot(500, [this]() {
        connectToServer();
    });
}

QClient::~QClient()
{
    disconnectFromServer();
}

void QClient::setupUI()
{
    auto* centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);
    
    auto* mainLayout = new QVBoxLayout(centralWidget);
    mainLayout->setSpacing(8);
    mainLayout->setContentsMargins(8, 8, 8, 8);
    
    // ==================== 顶部：连接状态栏 ====================
    m_connectionLabel = new QLabel("🔴 未连接到服务器", this);
    m_connectionLabel->setObjectName("connectionLabel");
    m_connectionLabel->setAlignment(Qt::AlignCenter);
    mainLayout->addWidget(m_connectionLabel);
    
    // ==================== 中部：消息显示区域 ====================
    m_messageBox = new QTextEdit(this);
    m_messageBox->setObjectName("messageBox");
    m_messageBox->setReadOnly(true);
    m_messageBox->setFont(QFont("Consolas", 9));
    mainLayout->addWidget(m_messageBox, 1);  // 占据最多空间
    
    // ==================== 底部：战斗面板 ====================
    auto* battlePanelFrame = new QFrame(this);
    battlePanelFrame->setObjectName("battlePanelFrame");
    battlePanelFrame->setFrameStyle(QFrame::Box);
    auto* battlePanelLayout = new QVBoxLayout(battlePanelFrame);
    
    // 状态信息区域 - 使用垂直布局改善空间利用
    auto* statusGroupLayout = new QVBoxLayout();
    statusGroupLayout->setSpacing(6);
    
    // 第一行：玩家基础状态
    auto* playerStatusLayout = new QHBoxLayout();
    m_playerStatusLabel = new QLabel("👤 等待连接...", this);
    m_playerStatusLabel->setObjectName("playerStatusLabel");
    playerStatusLayout->addWidget(m_playerStatusLabel);
    playerStatusLayout->addStretch();
    statusGroupLayout->addLayout(playerStatusLayout);
    
    // 第二行：游戏进度和怪物状态
    auto* gameInfoLayout = new QHBoxLayout();
    m_gameProgressLabel = new QLabel("🎮 等级: -- | 击杀: --", this);
    m_gameProgressLabel->setObjectName("gameProgressLabel");
    gameInfoLayout->addWidget(m_gameProgressLabel);
    gameInfoLayout->addStretch();
    statusGroupLayout->addLayout(gameInfoLayout);
    
    battlePanelLayout->addLayout(statusGroupLayout);
    
    // 控制按钮行
    auto* buttonLayout = new QHBoxLayout();
    buttonLayout->setSpacing(8);  // 减少按钮间距，避免过于拥挤
    buttonLayout->setContentsMargins(0, 8, 0, 4);  // 添加上下边距
    
    // 开始游戏/重新开始按钮（支持长按3秒重新开局）
    m_startButton = new QPushButton("🎮 开始游戏", this);
    m_startButton->setObjectName("startButton");
    
    // 🔄 支持长按重新开始：pressed开始长按，released取消长按，clicked处理普通点击
    connect(m_startButton, &QPushButton::pressed, this, &QClient::startLongPress);
    connect(m_startButton, &QPushButton::released, this, &QClient::cancelLongPress);
    connect(m_startButton, &QPushButton::clicked, this, &QClient::handleStartCommand);
    
    buttonLayout->addWidget(m_startButton);
    
    // 攻击按钮
    m_attackButton = new QPushButton("⚔️ 攻击", this);
    m_attackButton->setObjectName("attackButton");
    connect(m_attackButton, &QPushButton::clicked, this, &QClient::handleAttackCommand);
    buttonLayout->addWidget(m_attackButton);
    
    // 状态按钮
    m_statusButton = new QPushButton("📊 状态", this);
    m_statusButton->setObjectName("statusButton");
    connect(m_statusButton, &QPushButton::clicked, this, &QClient::handleStatusCommand);
    buttonLayout->addWidget(m_statusButton);
    
    // 帮助按钮
    m_helpButton = new QPushButton("❓ 帮助", this);
    m_helpButton->setObjectName("helpButton");
    connect(m_helpButton, &QPushButton::clicked, this, &QClient::handleHelpCommand);
    buttonLayout->addWidget(m_helpButton);
    
    battlePanelLayout->addLayout(buttonLayout);
    
    mainLayout->addWidget(battlePanelFrame);
    
    // ==================== 最底部：可折叠的调试和命令行区域 ====================
    
    // 折叠控制按钮
    m_collapseButton = new QPushButton("🔧 调试选项", this);
    m_collapseButton->setObjectName("collapseButton");
    connect(m_collapseButton, &QPushButton::clicked, this, &QClient::toggleDebugArea);
    mainLayout->addWidget(m_collapseButton);
    
    // 可折叠的调试区域
    m_debugFrame = new QFrame(this);
    m_debugFrame->setObjectName("debugFrame");
    m_debugFrame->setFrameStyle(QFrame::Box);
    auto* debugFrameLayout = new QVBoxLayout(m_debugFrame);
    debugFrameLayout->setContentsMargins(6, 6, 6, 6);
    debugFrameLayout->setSpacing(4);
    
    // 调试选项
    m_debugCheckBox = new QCheckBox("🔧 显示调试信息", this);
    m_debugCheckBox->setObjectName("debugCheckBox");
    m_debugCheckBox->setChecked(m_debugMode);
    connect(m_debugCheckBox, &QCheckBox::toggled, this, &QClient::onDebugModeChanged);
    debugFrameLayout->addWidget(m_debugCheckBox);
    
    // 命令行输入（保留，用于高级用户）
    auto* inputLayout = new QHBoxLayout();
    auto* inputLabel = new QLabel("命令:", this);
    inputLabel->setObjectName("inputLabel");
    
    m_commandInput = new QLineEdit(this);
    m_commandInput->setObjectName("commandInput");
    m_commandInput->setPlaceholderText("高级命令行 (可选)");
    m_commandInput->installEventFilter(this);
    
    inputLayout->addWidget(inputLabel);
    inputLayout->addWidget(m_commandInput);
    debugFrameLayout->addLayout(inputLayout);
    
    mainLayout->addWidget(m_debugFrame);
    
    // 初始化折叠动画
    m_collapseAnimation = new QPropertyAnimation(m_debugFrame, "maximumHeight", this);
    m_collapseAnimation->setDuration(200);  // 200ms动画时长
    m_collapseAnimation->setEasingCurve(QEasingCurve::InOutQuart);
    
    // 连接动画完成信号
    connect(m_collapseAnimation, &QPropertyAnimation::finished, this, [this]() {
        if (!m_debugAreaCollapsed) {
            // 展开完成后，移除高度限制，允许内容自由调整大小
            m_debugFrame->setMaximumHeight(16777215);
        }
    });
    
    // 设置初始折叠状态
    if (m_debugAreaCollapsed) {
        m_debugFrame->setMaximumHeight(0);
        m_debugFrame->setVisible(true);  // 保持可见，但高度为0
    } else {
        m_debugFrame->setMaximumHeight(16777215);  // Qt默认最大高度
    }
    
    // 设置折叠按钮的初始文字和样式
    if (m_debugAreaCollapsed) {
        m_collapseButton->setText("🔧 调试选项 ▶");  // 折叠状态，显示向右箭头
        m_collapseButton->setProperty("expanded", false);
    } else {
        m_collapseButton->setText("🔧 调试选项 ▼");  // 展开状态，显示向下箭头
        m_collapseButton->setProperty("expanded", true);
    }
    m_collapseButton->style()->unpolish(m_collapseButton);
    m_collapseButton->style()->polish(m_collapseButton);
    
    // 连接信号
    connect(m_commandInput, &QLineEdit::returnPressed, this, &QClient::SendCommandEvent);
    
    // 初始化按钮状态和UI显示
    updateConnectionStatus();  // 连接状态不需要锁
    {
        QMutexLocker locker(&m_playerDataMutex);
        updateButtonStates();
        updatePlayerStatus();
        updateGameProgress();
    }
}

void QClient::initializeNetwork()
{
    m_socket = new QUdpSocket(this);
    connect(m_socket, &QUdpSocket::readyRead, this, &QClient::onDataReceived);
}

bool QClient::eventFilter(QObject* obj, QEvent* event)
{
    if (obj == m_commandInput && event->type() == QEvent::KeyPress) 
    {
        QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
        if (keyEvent->key() == Qt::Key_Return || keyEvent->key() == Qt::Key_Enter) 
        {
            SendCommandEvent();
            return true;
        }
    }
    return QMainWindow::eventFilter(obj, event);
}

void QClient::SendCommandEvent()
{
    QString command = m_commandInput->text().trimmed();
    if (command.isEmpty()) 
    {
        return;
    }
    
    addSystemMessage(QString(">>> %1").arg(command));
    processCommand(command);
    clearCommandInput();
}

void QClient::connectToServer()
{
    // 如果已经有玩家ID，说明已经连接
    if (m_playerId > 0) 
    {
        return;
    }
    
    // 检查重连次数限制
    if (m_reconnectAttempts >= 5) 
    {
        addSystemMessage("❌ 连接失败次数过多，请检查服务器状态");
        addSystemMessage("💡 你可以重启客户端再次尝试连接");
        setWindowTitle("MUD冒险世界 - 连接失败");
        return;
    }
    
    m_connectionState = ConnectionState::CONNECTED;
    updateConnectionStatus();  // 更新连接状态显示
    
    // 更新按钮状态需要访问m_playerData，所以需要加锁
    {
        QMutexLocker locker(&m_playerDataMutex);
        updateButtonStates();
    }
    
    // 发送加入请求
    auto joinPacket = std::make_shared<GamePacket>(PacketType::PLAYER_JOIN, 0);
    sendPacket(joinPacket);
    
    if (m_reconnectAttempts == 0) {
        addSystemMessage("🔗 已发送连接请求，等待服务器响应...");
    } else {
        addSystemMessage(QString("🔄 第%1次重连尝试，等待服务器响应...").arg(m_reconnectAttempts + 1));
    }
    updateWindowTitle();
    
    // 设置连接超时检测
    QTimer::singleShot(5000, [this]() {
        if (m_playerId == 0) {
            // 5秒后仍未收到服务器响应，尝试重连
            m_reconnectAttempts++;
            addSystemMessage(QString("⚠️ 服务器响应超时 (尝试 %1/5)").arg(m_reconnectAttempts));
            m_connectionState = ConnectionState::DISCONNECTED;
            updateConnectionStatus();
            
            // 更新按钮状态需要访问m_playerData，所以需要加锁
            {
                QMutexLocker locker(&m_playerDataMutex);
                updateButtonStates();
            }
            
            // 3秒后重试
            QTimer::singleShot(3000, [this]() {
                addSystemMessage("🔄 正在重新连接服务器...");
                connectToServer();
            });
        }
    });
}

void QClient::disconnectFromServer()
{
    // 如果没有连接，直接返回
    if (m_playerId == 0) 
    {
        return;
    }
    
    // 发送离开通知
        auto leavePacket = std::make_shared<GamePacket>(PacketType::PLAYER_LEAVE, m_playerId);
        sendPacket(leavePacket);
    
    // 重置连接状态
    m_connectionState = ConnectionState::DISCONNECTED;
    m_playerId = 0;
    
    // 🔒 清除所有请求标志
    m_isStartRequestPending = false;
    m_isAttackRequestPending = false;
    
    addSystemMessage("🔌 已断开与服务器的连接");
    updateWindowTitle();
    updateConnectionStatus();
    
    // 加锁保护数据重置和UI更新
    {
        QMutexLocker locker(&m_playerDataMutex);
        m_playerData = PlayerGameData();
        m_monsterData = MonsterData();
        
        updateButtonStates();
        updatePlayerStatus();
        updateGameProgress();
    }
}

void QClient::sendPacket(std::shared_ptr<GamePacket> packet)
{
    if (!m_socket) 
    {
        addSystemMessage("❌ 网络错误：未初始化");
        return;
    }
    
    packet->timestamp = QDateTime::currentSecsSinceEpoch();
    QByteArray data = packet->serialize();
    
    addDebugMessage(QString("准备发送数据包 - 类型: %1, 玩家ID: %2, 大小: %3 字节")
                .arg(static_cast<int>(packet->type)).arg(packet->playerId).arg(data.size()));
    
    QHostAddress serverAddress = QHostAddress::LocalHost;
    qint64 sent = m_socket->writeDatagram(data, serverAddress, m_serverPort);
    
    if (sent == -1) 
    {
        addDebugMessage(QString("数据包发送失败: %1").arg(m_socket->errorString()));
        addSystemMessage("⚠️ 发送数据失败：" + m_socket->errorString());
        
        // 如果是连接相关的数据包发送失败，尝试重连
        if (packet->type == PacketType::PLAYER_JOIN) 
        {
            addSystemMessage("🔄 3秒后尝试重新连接...");
            QTimer::singleShot(3000, [this]() {
                m_connectionState = ConnectionState::DISCONNECTED;
                m_playerId = 0;
                connectToServer();
            });
        }
    } 
    else 
    {
        addDebugMessage(QString("数据包发送成功 - 发送了 %1 字节").arg(sent));
    }
}

void QClient::onDataReceived()
{
    while (m_socket && m_socket->hasPendingDatagrams()) 
    {
        QByteArray datagram;
        datagram.resize(static_cast<int>(m_socket->pendingDatagramSize()));
        
        QHostAddress sender;
        quint16 senderPort;
        
        qint64 size = m_socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
        
        if (size > 0) 
        {
            datagram.resize(static_cast<int>(size));
            processReceivedPacket(datagram);
        }
    }
}

void QClient::processReceivedPacket(const QByteArray& data)
{
    addDebugMessage(QString("收到数据包，大小: %1 字节").arg(data.size()));
    
    auto packet = GamePacket::deserialize(data);
    if (!packet) 
    {
        addDebugMessage("数据包反序列化失败");
        addSystemMessage("收到无效数据包");
        return;
    }
    
    addDebugMessage(QString("成功反序列化数据包，类型: %1").arg(static_cast<int>(packet->type)));
    
    switch (packet->type) 
    {
        case PacketType::PLAYER_JOIN:
            addDebugMessage("处理PLAYER_JOIN包");
            handlePlayerJoinResponse(packet);
            break;
        case PacketType::GAME_STATUS:
            addDebugMessage("处理GAME_STATUS包");
            handleGameStatus(packet);
            break;
        case PacketType::ATTACK:
            addDebugMessage("处理ATTACK包");
            handleAttackResult(packet);
            break;
        case PacketType::LEVEL_UP:
            addDebugMessage("处理LEVEL_UP包");
            handleLevelUp(packet);
            break;
        case PacketType::COMBAT_MESSAGE:  // 新增消息包类型
            addDebugMessage("准备处理COMBAT_MESSAGE包");
            handleCombatMessage(packet);
            break;
        default:
            addDebugMessage(QString("未知数据包类型: %1").arg(static_cast<int>(packet->type)));
            addSystemMessage(QString("收到未知类型数据包: %1").arg(static_cast<int>(packet->type)));
            break;
    }
}

void QClient::processCommand(const QString& command)
{
    if (command.isEmpty()) 
    {
        return;
    }
    
    QStringList parts = command.split(' ', Qt::SkipEmptyParts);
    if (parts.isEmpty()) 
    {
        addSystemMessage("无效指令");
        return;
    }
    
    QString cmd = parts[0].toLower();
    
    if (cmd == "/start") 
    {
        handleStartCommand();
    } 
    else if (cmd == "/attack") 
    {
        handleAttackCommand();
    } 
    else if (cmd == "/status") 
    {
        handleStatusCommand();
    } 
    else if (cmd == "/help") 
    {
        handleHelpCommand();
    } 
    else 
    {
        addSystemMessage("未知指令: " + cmd);
        addSystemMessage("输入 /help 查看可用指令");
    }
}

// 指令处理函数
void QClient::handleStartCommand()
{
    addDebugMessage("handleStartCommand被调用");
    addDebugMessage(QString("当前玩家ID: %1").arg(m_playerId));
    
    // 🔒 安全检查1：连接状态
    if (m_connectionState != ConnectionState::CONNECTED || m_playerId == 0) 
    {
        addDebugMessage("连接状态异常或玩家ID无效");
        addSystemMessage("⚠️ 尚未连接到服务器，请等待连接完成");
        return;
    }
    
    // 🔒 安全检查2：防止重复请求（3秒内只能发送一次开始请求）
    QDateTime currentTime = QDateTime::currentDateTime();
    if (m_isStartRequestPending) {
        addDebugMessage("开始游戏请求仍在等待响应中");
        addSystemMessage("⚠️ 游戏正在准备中，请耐心等待...");
        return;
    }
    
    if (m_lastStartRequest.isValid() && m_lastStartRequest.msecsTo(currentTime) < 3000) {
        addDebugMessage("开始游戏请求过于频繁");
        addSystemMessage("⚠️ 操作过于频繁，请等待3秒后再试");
        return;
    }
    
    // 🔄 新逻辑：战斗中或游戏中的点击无效，需要长按重新开始
    {
        QMutexLocker locker(&m_playerDataMutex);
        if (m_playerData.gameState == GameState::IN_COMBAT) 
        {
            addSystemMessage("⚠️ 游戏正在进行中！");
            addSystemMessage("💡 如需重新开局，请长按此按钮3秒");
            addSystemMessage("📢 长按时会显示进度条确认操作");
            return;
        }
        
        if (m_playerData.isInAutoCombat) 
        {
            addSystemMessage("⚠️ 自动战斗正在进行中！");
            addSystemMessage("💡 如需重新开局，请长按此按钮3秒");
            return;
        }
        
        // 🔒 安全检查3：重要操作确认
        if (m_playerData.level > 1 || m_playerData.totalKills > 0) 
        {
            QMessageBox::StandardButton reply = QMessageBox::question(
                this, 
                "⚠️ 确认重新开始", 
                QString("你当前等级为 %1，击杀数为 %2\n\n重新开始将会重置所有进度！\n\n确定要继续吗？")
                    .arg(m_playerData.level)
                    .arg(m_playerData.totalKills),
                QMessageBox::Yes | QMessageBox::No,
                QMessageBox::No
            );
            
            if (reply != QMessageBox::Yes) 
            {
                addSystemMessage("📋 重新开始操作已取消");
                return;
            }
        }
        
        // 🔒 立即禁用按钮，防止重复点击
        if (m_startButton) {
            m_startButton->setEnabled(false);
            m_startButton->setText("📡 准备中...");
        }
        if (m_attackButton) {
            m_attackButton->setEnabled(false);
        }
    }
    
    addDebugMessage("安全检查通过，创建GAME_START数据包");
    
    // 🔒 设置请求状态标志，防止重复点击
    m_isStartRequestPending = true;
    m_lastStartRequest = currentTime;
    
    auto startPacket = std::make_shared<GamePacket>(PacketType::GAME_START, m_playerId);
    
    addDebugMessage("调用sendPacket发送GAME_START数据包");
    sendPacket(startPacket);
    
    addSystemMessage("🎮 正在准备游戏...");
    addSystemMessage("⚡ 已发送开始请求到服务器");
    addSystemMessage("🎯 准备生成敌人和战斗环境...");
    
    // 🔒 安全机制：10秒超时保护，防止按钮永久禁用
    if (m_timeoutTimer) {
        m_timeoutTimer->start(10000);
    }
}

void QClient::handleAttackCommand()
{
    // 🔒 安全检查1：连接状态
    if (m_connectionState != ConnectionState::CONNECTED || m_playerId == 0) 
    {
        addSystemMessage("⚠️ 尚未连接到服务器，请等待连接完成");
        return;
    }
    
    // 🔒 安全检查2：防止重复请求和流程错乱
    QDateTime currentTime = QDateTime::currentDateTime();
    
    // 检查是否有开始游戏请求正在等待响应
    if (m_isStartRequestPending) {
        addDebugMessage("开始游戏请求仍在等待响应，拒绝攻击请求");
        addSystemMessage("⚠️ 游戏正在准备中，请等待准备完成后再攻击！");
        return;
    }
    
    // 检查是否有攻击请求正在等待响应
    if (m_isAttackRequestPending) {
        addDebugMessage("攻击请求仍在等待响应中");
        addSystemMessage("⚠️ 攻击请求正在处理中，请耐心等待...");
        return;
    }
    
    // 防止攻击请求过于频繁（2秒内只能发送一次）
    if (m_lastAttackRequest.isValid() && m_lastAttackRequest.msecsTo(currentTime) < 2000) {
        addDebugMessage("攻击请求过于频繁");
        addSystemMessage("⚠️ 攻击操作过于频繁，请等待2秒后再试");
        return;
    }
    
    // 🔒 安全检查3：游戏状态验证
    {
        QMutexLocker locker(&m_playerDataMutex);
        
        if (m_playerData.gameState == GameState::PREPARING) 
        {
            addSystemMessage("⚠️ 正在准备下一关，请等待倒计时结束！");
            return;
        }
        
        if (m_playerData.gameState != GameState::IN_COMBAT) 
        {
            addSystemMessage("⚠️ 你当前不在战斗状态！请先点击 '🎮 开始游戏' 按钮");
            return;
        }
        
        if (m_playerData.isInAutoCombat) 
        {
            addSystemMessage("⚠️ 战斗已经在进行中，请耐心等待战斗结束！");
            return;
        }
        
        // 🔒 立即禁用攻击按钮，防止重复点击
        if (m_attackButton) {
            m_attackButton->setEnabled(false);
            m_attackButton->setText("⚔️ 战斗中...");
            m_attackButton->setProperty("state", "fighting");
            m_attackButton->style()->unpolish(m_attackButton);
            m_attackButton->style()->polish(m_attackButton);
        }
    }
    
    addDebugMessage("攻击安全检查通过，准备发起攻击");
    
    // 🔒 设置攻击请求状态标志，防止重复点击
    m_isAttackRequestPending = true;
    m_lastAttackRequest = currentTime;
    
    auto attackPacket = std::make_shared<GamePacket>(PacketType::ATTACK, m_playerId);
    sendPacket(attackPacket);
    
    addSystemMessage("⚔️ 已发送自动战斗请求...");
    addSystemMessage("🎯 准备开始自动战斗模式！");
    addSystemMessage("👀 请注意观察下方的战斗消息");
    addSystemMessage("💡 你可以观察战斗消息了解战斗进展");
    
    // 🔒 安全机制：5秒超时保护，防止攻击按钮永久禁用
    if (m_timeoutTimer) {
        m_timeoutTimer->start(5000);
    }
    
    // 更新按钮状态需要访问m_playerData，所以需要加锁
    {
        QMutexLocker locker(&m_playerDataMutex);
        updateButtonStates();
    }
}

void QClient::handleStatusCommand() 
{
    addDebugMessage("执行 /status 命令");
    
    // 🔒 安全检查：防止频繁查询状态（2秒内最多查询一次）
    QDateTime currentTime = QDateTime::currentDateTime();
    if (m_lastStatusCheck.isValid() && m_lastStatusCheck.msecsTo(currentTime) < 2000) {
        addSystemMessage("⚠️ 查询过于频繁，请等待2秒后再试");
        return;
    }
    m_lastStatusCheck = currentTime;
    
    QMutexLocker locker(&m_playerDataMutex);
    
    addSystemMessage("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    addSystemMessage("📊 **玩家详细状态**");
    addSystemMessage("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    QString stateText;
    switch (m_playerData.gameState) {
        case GameState::WAITING:
            stateText = "🔵 等待中 - 输入 /start 开始游戏";
            break;
        case GameState::PREPARING:
            stateText = "🟠 准备下一关 - 倒计时中，请稍候";
            break;
        case GameState::IN_COMBAT:
            if (m_playerData.isInAutoCombat) {
                stateText = "🔴 自动战斗中";
            } else {
                stateText = "🟡 战斗准备 - 输入 /attack 开始";
            }
            break;
        default:
            stateText = "❓ 未知状态";
            break;
    }
    
    addSystemMessage(QString("🎮 游戏状态: %1").arg(stateText));
    addSystemMessage(QString("🎯 当前关卡: %1").arg(m_playerData.level));
    addSystemMessage("");
    
    // 基础属性
    addSystemMessage("⚔️ **战斗属性**");
    addSystemMessage(QString("   ❤️ 血量: %1/%2").arg(m_playerData.health).arg(m_playerData.maxHealth));
    addSystemMessage(QString("   ⚔️ 攻击力: %1").arg(m_playerData.attackPower));
    addSystemMessage(QString("   🛡️ 防御力: %1").arg(m_playerData.defense));
    addSystemMessage(QString("   ⚡ 暴击率: %1°").arg(m_playerData.critChance));
    addSystemMessage(QString("   💥 暴击倍数: %1x").arg(QString::number(m_playerData.critMultiplier, 'f', 1)));
    addSystemMessage(QString("   🎯 命中率: %1°").arg(m_playerData.hitChance));
    addSystemMessage(QString("   💨 闪避率: %1°").arg(m_playerData.dodgeChance));
    addSystemMessage("");
    
    // 血量状态条
    int healthPercent = (m_playerData.health * 100) / m_playerData.maxHealth;
    QString healthBar = "💚";
    if (healthPercent <= 25) {
        healthBar = "❤️ 危险";
    } else if (healthPercent <= 50) {
        healthBar = "💛 一般";
    } else if (healthPercent <= 75) {
        healthBar = "💙 良好";
    } else {
        healthBar = "💚 优秀";
    }
    addSystemMessage(QString("🩺 健康状况: %1 (%2°)").arg(healthBar).arg(healthPercent));
    

    
    addSystemMessage("");
    addSystemMessage(QString("🏆 总击杀数: %1").arg(m_playerData.totalKills));
    
    // 显示游戏进度
    QString progressInfo;
    if (m_playerData.level <= 9) {
        progressInfo = QString("🟢 第 %1 关 (威胁等级：⭐ 初级)").arg(m_playerData.level);
    } else if (m_playerData.level == 10) {
        progressInfo = "🏆 第一阶段Boss关！";
    } else if (m_playerData.level <= 19) {
        progressInfo = QString("🟡 第 %1 关 (威胁等级：⭐⭐ 中级)").arg(m_playerData.level);
    } else if (m_playerData.level == 20) {
        progressInfo = "🏆 第二阶段Boss关！";
    } else if (m_playerData.level <= 29) {
        progressInfo = QString("🔴 第 %1 关 (威胁等级：⭐⭐⭐ 高级)").arg(m_playerData.level);
    } else if (m_playerData.level == 30) {
        progressInfo = "👑 最终Boss关！";
    } else {
        progressInfo = "🎊 游戏已完成！";
    }
    
    addSystemMessage(QString("📈 游戏进度: %1").arg(progressInfo));
    addSystemMessage("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    if (m_playerData.gameState == GameState::WAITING) {
        addSystemMessage("💡 提示: 输入 /start 开始新的关卡");
    } else if (m_playerData.gameState == GameState::IN_COMBAT && !m_playerData.isInAutoCombat) {
        addSystemMessage("💡 提示: 输入 /attack 开始自动战斗");
    }
}

void QClient::handleHelpCommand()
{
    displayGameHelp();
}

// 数据包处理函数
void QClient::handlePlayerJoinResponse(std::unique_ptr<GamePacket>& packet)
{
    m_playerId = packet->playerId;
    m_playerData = PlayerGameData(); // 初始化玩家数据
    
    // 重置重连计数器
    m_reconnectAttempts = 0;
    
    // 🔒 收到连接响应，取消超时保护
    if (m_timeoutTimer && m_timeoutTimer->isActive()) {
        m_timeoutTimer->stop();
        addDebugMessage("收到连接响应，取消超时保护");
    }
    
    addSystemMessage("✅ 成功连接到服务器！");
    addSystemMessage(QString("🆔 你的玩家ID: %1").arg(m_playerId));
    addSystemMessage("==============================");
    addSystemMessage("🎯 游戏已准备就绪！");
    addSystemMessage("💡 输入 /start 开始你的冒险之旅");
    addSystemMessage("💡 输入 /help 查看详细指令说明");
    addSystemMessage("==============================");
    addSystemMessage("📨 等待服务器发送详细游戏信息...");
    
    updateWindowTitle();
    updateConnectionStatus();
    
    // 加锁保护UI更新，因为updatePlayerStatus和updateGameProgress需要访问m_playerData
    {
        QMutexLocker locker(&m_playerDataMutex);
        updateButtonStates();
        updatePlayerStatus();
        updateGameProgress();
    }
}

void QClient::handleGameStatus(std::unique_ptr<GamePacket>& packet)
{
    auto statusPacket = dynamic_cast<GameStatusPacket*>(packet.get());
    if (!statusPacket) 
    {
        return;
    }
    
    // 🔒 收到游戏状态响应，清除开始游戏请求标志
    if (m_isStartRequestPending) {
        m_isStartRequestPending = false;
        addDebugMessage("收到游戏状态响应，清除开始游戏请求标志");
    }
    
    // 显示状态信息
    if (!statusPacket->message.isEmpty()) 
    {
        addGameMessage(statusPacket->message);
    }
    
    // 加锁保护共享数据的修改和UI更新
    {
        QMutexLocker locker(&m_playerDataMutex);
        
        // 更新游戏数据
        m_playerData = statusPacket->playerData;
        m_monsterData = statusPacket->monsterData;
        
        // 根据游戏状态提供操作提示
        if (m_playerData.gameState == GameState::IN_COMBAT) 
        {
            if (m_playerData.isInAutoCombat) 
            {
                addSystemMessage("⚔️ 自动战斗进行中，请耐心等待...");
            } 
            else 
            {
                // 刚进入战斗状态，等待服务器发送详细的战斗信息
                addSystemMessage("✅ 游戏准备完成！");
                addSystemMessage("📋 正在加载详细战斗信息...");
                addSystemMessage("👀 请观察下方的红色战斗消息");
            }
        } 
        else if (m_playerData.gameState == GameState::WAITING) 
        {
            // 🏆 检查是否是死亡重置或通关重置（level=1, totalKills=0, health=初始值）
            bool isGameReset = (m_playerData.level == 1 && m_playerData.totalKills == 0 && 
                               m_playerData.health == m_playerData.maxHealth);
            
            if (isGameReset) {
                addSystemMessage("🔄 游戏已重置完成！");
                addSystemMessage("🎮 点击 '🎮 开始游戏' 按钮开始新的冒险！");
            } else {
                addSystemMessage("💡 点击 '🎮 开始游戏' 按钮继续冒险");
            }
        }
        
        // 🔄 如果是游戏重置状态，清除任何长按状态
        bool isGameReset = (m_playerData.level == 1 && m_playerData.totalKills == 0 && 
                           m_playerData.health == m_playerData.maxHealth &&
                           m_playerData.gameState == GameState::WAITING);
        
        if (isGameReset && (m_isLongPressing || m_isReverseAnimating)) {
            addDebugMessage("游戏重置，清除长按状态");
            if (m_isLongPressing) {
                m_isLongPressing = false;
                m_longPressTimer->stop();
                m_progressTimer->stop();
            }
            if (m_isReverseAnimating) {
                m_isReverseAnimating = false;
                m_reverseTimer->stop();
            }
            m_longPressProgress = 0;
        }
        
        // 更新UI状态（在锁内调用，因为UI方法不再自己加锁）
        updatePlayerStatus();
        updateGameProgress();
        updateButtonStates();
    }
}

void QClient::handleAttackResult(std::unique_ptr<GamePacket>& packet)
{
    auto attackPacket = dynamic_cast<AttackPacket*>(packet.get());
    if (!attackPacket) 
    {
        return;
    }
    
    // 🔒 收到攻击响应，清除攻击请求标志
    if (m_isAttackRequestPending) {
        m_isAttackRequestPending = false;
        addDebugMessage("收到攻击响应，清除攻击请求标志");
    }
    
    // 🔒 收到攻击响应，取消超时保护
    if (m_timeoutTimer && m_timeoutTimer->isActive()) {
        m_timeoutTimer->stop();
        addDebugMessage("收到攻击响应，取消超时保护");
    }
    
    addGameMessage("⚔️ " + attackPacket->message);
    
    // 继续战斗
    if (m_playerData.gameState == GameState::IN_COMBAT && m_playerData.isAlive()) 
    {
        addSystemMessage("💡 输入 /attack 继续攻击");
    }
}

void QClient::handleLevelUp(std::unique_ptr<GamePacket>& packet)
{
    auto levelUpPacket = dynamic_cast<LevelUpPacket*>(packet.get());
    if (!levelUpPacket) 
    {
        return;
    }
    
    // 🏆 检查是否是通关重置（level=1 且 totalKills=0）
    bool isGameReset = (levelUpPacket->newPlayerData.level == 1 && 
                       levelUpPacket->newPlayerData.totalKills == 0 &&
                       levelUpPacket->newPlayerData.gameState == GameState::WAITING);
    
    if (isGameReset) {
        addGameMessage("🎉 " + levelUpPacket->message);
        addSystemMessage("🏆 恭喜通关！游戏已重置到初始状态");
        addSystemMessage("🎮 点击'开始游戏'按钮开始新的冒险！");
        addDebugMessage("handleLevelUp: 检测到通关重置，游戏回到初始状态");
    } else {
        addGameMessage("🎉 " + levelUpPacket->message);
        addSystemMessage("💡 准备进入下一关...");
        addDebugMessage("handleLevelUp: 普通升级");
    }
    
    // 加锁保护共享数据的修改和UI更新
    {
        QMutexLocker locker(&m_playerDataMutex);
        
        addDebugMessage(QString("handleLevelUp: 更新前 - level=%1, totalKills=%2, gameState=%3")
                       .arg(m_playerData.level).arg(m_playerData.totalKills)
                       .arg(static_cast<int>(m_playerData.gameState)));
        
        // 更新玩家数据
        m_playerData = levelUpPacket->newPlayerData;
        
        addDebugMessage(QString("handleLevelUp: 更新后 - level=%1, totalKills=%2, gameState=%3")
                       .arg(m_playerData.level).arg(m_playerData.totalKills)
                       .arg(static_cast<int>(m_playerData.gameState)));
        
        // 更新UI状态（在锁内调用，因为UI方法不再自己加锁）
        updatePlayerStatus();
        updateGameProgress();
        updateButtonStates();  // 🏆 新增：确保按钮状态正确更新（特别是通关后重置时）
        
        // 🏆 如果是通关重置，额外确保长按状态被清除
        if (isGameReset && m_isLongPressing) {
            addDebugMessage("handleLevelUp: 通关重置时发现长按状态，强制取消");
            // 注意：这里不能调用cancelLongPress()，因为它会尝试获取同一个锁
            // 直接清除状态
            m_isLongPressing = false;
            m_longPressProgress = 0;
            m_longPressTimer->stop();
            m_progressTimer->stop();
        }
    }
}

// 新增：处理战斗消息
void QClient::handleCombatMessage(std::unique_ptr<GamePacket>& packet)
{
    addDebugMessage("[客户端] 进入handleCombatMessage方法");
    
    auto combatPacket = dynamic_cast<CombatMessagePacket*>(packet.get());
    if (!combatPacket) 
    {
        addDebugMessage("handleCombatMessage: 无法转换为CombatMessagePacket");
        addDebugMessage(QString("原始包类型: %1, 玩家ID: %2").arg(static_cast<int>(packet->type)).arg(packet->playerId));
        return;
    }
    
    // 🔒 收到战斗消息，清除攻击请求标志（如果是第一条战斗消息响应）
    if (m_isAttackRequestPending) {
        m_isAttackRequestPending = false;
        addDebugMessage("收到战斗消息响应，清除攻击请求标志");
    }
    
    // 🔒 收到战斗消息，取消超时保护（如果是第一条战斗消息响应）
    if (m_timeoutTimer && m_timeoutTimer->isActive()) {
        m_timeoutTimer->stop();
        addDebugMessage("收到战斗消息响应，取消超时保护");
    }
    
    addDebugMessage(QString("[客户端] 成功转换CombatMessagePacket，消息: %1").arg(combatPacket->message));
    addDebugMessage(QString("[客户端] 收到战斗消息: %1").arg(combatPacket->message));
    
    // 🔒 检测倒计时消息，设置准备状态
    QString message = combatPacket->message;
    if (message.contains("3秒后开始下一关") || 
        message.contains("3秒后开始Boss战") ||
        message.contains("准备进入下一关") ||
        message.contains("神启升级下一关")) {
        
        addDebugMessage("检测到倒计时消息，设置游戏状态为PREPARING");
        
        // 设置游戏状态为准备中
        {
            QMutexLocker locker(&m_playerDataMutex);
            m_playerData.gameState = GameState::PREPARING;
            updateButtonStates();
        }
        
        // 3秒后自动恢复到等待攻击状态（防止服务器状态同步延迟）
        QTimer::singleShot(3500, [this]() {
            addDebugMessage("倒计时结束，检查游戏状态");
            QMutexLocker locker(&m_playerDataMutex);
            if (m_playerData.gameState == GameState::PREPARING) {
                // 如果3.5秒后状态仍然是PREPARING，说明可能服务器状态同步有延迟
                // 这时应该允许攻击了
                addDebugMessage("倒计时超时，状态仍为PREPARING，自动恢复");
                if (m_playerData.level > 0) {
                    m_playerData.gameState = GameState::IN_COMBAT;
                }
                updateButtonStates();
            }
        });
    }
    
    addCombatMessage(combatPacket->message);
}

// 显示函数
QString QClient::displayPlayerStats() const
{
    QString stateText;
    switch (m_playerData.gameState) 
    {
        case GameState::WAITING: stateText = "等待中"; break;
        case GameState::PREPARING: stateText = "准备下一关"; break;
        case GameState::IN_COMBAT: 
            stateText = m_playerData.isInAutoCombat ? "自动战斗中" : "战斗中"; 
            break;
        default: stateText = "未知"; break;
    }
    
    return QString("👤 玩家状态: 第%1关 | 生命:%2/%3 | 攻击:%4 | 击杀:%5 | 状态:%6")
           .arg(m_playerData.level)
           .arg(m_playerData.health)
           .arg(m_playerData.maxHealth)
           .arg(m_playerData.attackPower)
           .arg(m_playerData.totalKills)
           .arg(stateText);
}

QString QClient::displayMonsterInfo() const
{
    if (m_monsterData.name.isEmpty()) 
    {
        return "👹 怪物状态: 无";
    }
    
    return QString("👹 %1: 生命:%2/%3 | 攻击:%4")
           .arg(m_monsterData.name)
           .arg(m_monsterData.health)
           .arg(m_monsterData.maxHealth)
           .arg(m_monsterData.attackPower);
}

void QClient::displayGameHelp()
{
    addSystemMessage("======================== 游戏帮助 ========================");
    addSystemMessage("🎮 MUD冒险游戏操作指南");
    addSystemMessage("");
    addSystemMessage("🖱️ 战斗面板操作:");
    addSystemMessage("   🎮 开始游戏  - 开始新游戏或新关卡");
    addSystemMessage("   🔄 重新开始  - 长按3秒重新开局（游戏中显示）");
    addSystemMessage("   ⚔️ 攻击      - 开始自动战斗模式");
    addSystemMessage("   📊 状态      - 查看当前游戏状态");
    addSystemMessage("   ❓ 帮助      - 显示此帮助信息");
    addSystemMessage("");
    addSystemMessage("⌨️ 高级命令行 (可选):");
    addSystemMessage("   /start      - 开始新游戏或新关卡");
    addSystemMessage("   /attack     - 开始自动战斗模式");
    addSystemMessage("   /status     - 查看当前游戏状态");
    addSystemMessage("   /help       - 显示此帮助信息");
    addSystemMessage("");
    addSystemMessage("🎯 游戏规则:");
    addSystemMessage("   • 30关卡系统: 1-9初级 | 10,20,30Boss关 | 11-19中级 | 21-29高级");
    addSystemMessage("   • 威胁等级: ⭐初级 ⭐⭐中级 ⭐⭐⭐高级");
    addSystemMessage("   • 圆桌战斗: 命中→闪避→暴击→防御→伤害");
    addSystemMessage("   • 属性系统: 血量、攻击、防御、暴击、命中、闪避");
    addSystemMessage("   • 随机奖励: 击败敌人有概率获得属性提升");
    addSystemMessage("   • 自动战斗: 点击攻击按钮后完全自动，直到胜负决出");
    addSystemMessage("   • 🏆 通关重置: 完成30关后自动重置，按钮变回'开始游戏'");
    addSystemMessage("");
    addSystemMessage("🔒 安全功能:");
    addSystemMessage("   • 智能按钮: 初始状态显示'开始游戏'，游戏中显示'重新开始'");
    addSystemMessage("   • 长按重新开始: 游戏中长按开始按钮3秒可重新开局");
    addSystemMessage("   • 🏆 通关自动重置: 30关后自动变回'开始游戏'，无需长按");
    addSystemMessage("   • 进度确认: 长按时显示进度条，避免误操作");
    addSystemMessage("   • 防重复点击: 按钮状态智能管理，防止重复操作");
    addSystemMessage("   • 状态检查: 系统自动验证操作有效性");
    addSystemMessage("");
    addSystemMessage("🔗 连接说明:");
    addSystemMessage("   • 游戏启动时自动连接服务器");
    addSystemMessage("   • 连接状态显示在顶部状态栏");
    addSystemMessage("   • 连接失败会自动重试");
    addSystemMessage("");
    addSystemMessage("💡 快速开始: 点击 🎮开始游戏 → ⚔️攻击");
    addSystemMessage("🎮 全新UI界面，操作更便捷！");
    addSystemMessage("🔄 长按重新开始，安全又便捷！");
    addSystemMessage("======================================================");
}

void QClient::addSystemMessage(const QString& message)
{
    if (m_messageBox) 
    {
        QString formattedMessage = QString("<span style='color: #C0C0C0; font-weight: bold;'>🖥️ SYSTEM:</span> <span style='color: #FFFFFF;'>%1</span>")
                                  .arg(message);
        m_messageBox->append(formattedMessage);
    }
}

void QClient::addGameMessage(const QString& message)
{
    if (m_messageBox) 
    {
        QString formattedMessage = QString("<span style='color: #7FFF00; font-weight: bold;'>🎮 GAME:</span> <span style='color: #90EE90;'>%1</span>")
                                  .arg(message);
        m_messageBox->append(formattedMessage);
    }
}

void QClient::addCombatMessage(const QString& message)
{
    if (m_debugMode) {
        qDebug() << QString("[客户端] addCombatMessage被调用，消息: %1").arg(message);
    }
    
    if (m_messageBox) 
    {
        QString formattedMessage = QString("<span style='color: #FFB6C1; font-weight: bold; font-size: 11px;'>⚔️ COMBAT:</span> <span style='color: #DC143C; font-weight: bold;'>%1</span>")
                                  .arg(message);
        m_messageBox->append(formattedMessage);
        
        if (m_debugMode) {
            qDebug() << "[客户端] 战斗消息已添加到界面";
        }
        
        // 自动滚动到底部
        QTextCursor cursor = m_messageBox->textCursor();
        cursor.movePosition(QTextCursor::End);
        m_messageBox->setTextCursor(cursor);
        m_messageBox->ensureCursorVisible();
        } 
        else 
        {
        if (m_debugMode) {
            qDebug() << "[客户端] 错误: m_messageBox为空，无法显示消息";
        }
    }
}

// 新增：调试模式切换槽函数
void QClient::onDebugModeChanged(bool enabled)
{
    m_debugMode = enabled;
    if (enabled) {
        addDebugMessage("调试模式已开启");
    } else {
        addSystemMessage("调试模式已关闭");
    }
}

// 新增：调试区域折叠切换槽函数
void QClient::toggleDebugArea()
{
    m_debugAreaCollapsed = !m_debugAreaCollapsed;
    
    // 更新折叠按钮的文字、图标和样式
    if (m_debugAreaCollapsed) {
        m_collapseButton->setText("🔧 调试选项 ▶");  // 折叠状态，显示向右箭头
        m_collapseButton->setProperty("expanded", false);
    } else {
        m_collapseButton->setText("🔧 调试选项 ▼");  // 展开状态，显示向下箭头
        m_collapseButton->setProperty("expanded", true);
    }
    m_collapseButton->style()->unpolish(m_collapseButton);
    m_collapseButton->style()->polish(m_collapseButton);
    
    // 使用动画切换调试区域的高度
    if (m_debugAreaCollapsed) {
        // 折叠：从当前高度动画到0
        m_collapseAnimation->setStartValue(m_debugFrame->height());
        m_collapseAnimation->setEndValue(0);
    } else {
        // 展开：从0动画到内容的实际高度
        m_debugFrame->setMaximumHeight(16777215);  // 先移除高度限制
        int contentHeight = m_debugFrame->sizeHint().height();  // 获取内容实际高度
        m_debugFrame->setMaximumHeight(0);  // 重新设置为0开始动画
        
        m_collapseAnimation->setStartValue(0);
        m_collapseAnimation->setEndValue(contentHeight);
    }
    
    m_collapseAnimation->start();
    
    addDebugMessage(QString("调试区域已%1").arg(m_debugAreaCollapsed ? "折叠" : "展开"));
}

// 新增：添加调试消息
void QClient::addDebugMessage(const QString& message)
{
    if (!m_debugMode) {
        return; // 调试模式关闭时不显示调试消息
    }
    
    if (m_messageBox) 
    {
        QString formattedMessage = QString("<span style='color: #808080; font-size: 9px; font-weight: bold;'>🔧 DEBUG:</span> <span style='color: #A9A9A9; font-size: 9px;'>%1</span>")
                                  .arg(message);
        m_messageBox->append(formattedMessage);
        
        // 自动滚动到底部
        QTextCursor cursor = m_messageBox->textCursor();
        cursor.movePosition(QTextCursor::End);
        m_messageBox->setTextCursor(cursor);
        m_messageBox->ensureCursorVisible();
    }
}

void QClient::updateWindowTitle()
{
    QString title = "MUD冒险世界";
    
    if (m_playerId > 0) 
    {
        title += QString(" - 勇士_%1").arg(m_playerId);
    } 
    else 
    {
        title += " - 连接中...";
    }
    
    setWindowTitle(title);
}

void QClient::loadStyleSheet()
{
    QFile styleFile(":/style.qss");
    if (!styleFile.exists()) {
        // 如果资源文件不存在，尝试从文件系统加载
        styleFile.setFileName("style.qss");
    }
    
    if (styleFile.open(QFile::ReadOnly)) {
        QString styleSheet = QLatin1String(styleFile.readAll());
        this->setStyleSheet(styleSheet);
        addDebugMessage("QSS样式表加载成功");
    } else {
        addDebugMessage("警告：QSS样式表加载失败，使用默认样式");
    }
}

void QClient::clearCommandInput()
{
    if (m_commandInput) 
    {
        m_commandInput->clear();
    }
}

void QClient::closeEvent(QCloseEvent* event)
{
    // 如果已经连接到服务器，发送离开通知
    if (m_playerId > 0) 
    {
        auto leavePacket = std::make_shared<GamePacket>(PacketType::PLAYER_LEAVE, m_playerId);
        sendPacket(leavePacket);
        
        // 等待一小段时间确保数据包发送
        QEventLoop loop;
        QTimer::singleShot(100, &loop, &QEventLoop::quit);
        loop.exec();
    }
    
    event->accept();
}

// ==================== 新增：UI状态更新方法 ====================

void QClient::updatePlayerStatus()
{
    if (!m_playerStatusLabel) return;
    
    // 注意：调用者负责加锁 m_playerDataMutex
    if (m_connectionState == ConnectionState::CONNECTED && m_playerId != 0) {
        // 简化显示，突出重要信息
        QString status = QString("👤 生命:%1/%2 | ⚔️攻击:%3 | 🛡️防御:%4 | 等级:%5")
            .arg(m_playerData.health)
            .arg(m_playerData.maxHealth)
            .arg(m_playerData.attackPower)
            .arg(m_playerData.defense)
            .arg(m_playerData.level);
        m_playerStatusLabel->setText(status);
    } else {
        m_playerStatusLabel->setText("👤 等待连接...");
    }
}

void QClient::updateGameProgress()
{
    if (!m_gameProgressLabel) return;
    
    // 注意：调用者负责加锁 m_playerDataMutex
    if (m_connectionState == ConnectionState::CONNECTED && m_playerId != 0) {
        QString progress = QString("🎮 第%1关 | 🏆 击杀:%2")
            .arg(m_playerData.level)
            .arg(m_playerData.totalKills);
            
        // 🔥 简化怪物状态显示
        QString monsterStatus;
        if (m_monsterData.name.isEmpty()) {
            monsterStatus = " | 👹 无敌人";
        } else {
            monsterStatus = QString(" | 👹 %1 生命:%2/%3")
                .arg(m_monsterData.name)
                .arg(m_monsterData.health)
                .arg(m_monsterData.maxHealth);
        }
        
        progress += monsterStatus;
        m_gameProgressLabel->setText(progress);
    } else {
        m_gameProgressLabel->setText("🎮 等级: -- | 击杀: -- | 👹 等待连接...");
    }
}

void QClient::updateConnectionStatus()
{
    if (!m_connectionLabel) return;
    
    switch (m_connectionState) {
        case ConnectionState::DISCONNECTED:
            m_connectionLabel->setText("🔴 未连接到服务器");
            m_connectionLabel->setProperty("connectionState", "disconnected");
            break;
        case ConnectionState::CONNECTING:
            m_connectionLabel->setText("🟡 正在连接服务器...");
            m_connectionLabel->setProperty("connectionState", "connecting");
            break;
        case ConnectionState::CONNECTED:
            m_connectionLabel->setText(QString("🟢 已连接 | 玩家ID: %1").arg(m_playerId));
            m_connectionLabel->setProperty("connectionState", "connected");
            break;
    }
    m_connectionLabel->style()->unpolish(m_connectionLabel);
    m_connectionLabel->style()->polish(m_connectionLabel);
}

void QClient::updateButtonStates()
{
    bool connected = (m_connectionState == ConnectionState::CONNECTED);
    // 注意：调用者负责加锁 m_playerDataMutex
    bool inCombat = m_playerData.isInAutoCombat;
    bool inGame = (m_playerData.gameState == GameState::IN_COMBAT);
    bool isPreparing = (m_playerData.gameState == GameState::PREPARING);
    
    // 🏆 判断是否是初始状态（通关重置后或游戏刚开始）
    bool isInitialState = (m_playerData.gameState == GameState::WAITING && 
                          m_playerData.level == 1 && 
                          m_playerData.totalKills == 0);
    
    addDebugMessage(QString("updateButtonStates: connected=%1, inCombat=%2, inGame=%3, isPreparing=%4, isInitial=%5")
                   .arg(connected).arg(inCombat).arg(inGame).arg(isPreparing).arg(isInitialState));
    addDebugMessage(QString("playerData: gameState=%1, level=%2, totalKills=%3")
                   .arg(static_cast<int>(m_playerData.gameState)).arg(m_playerData.level).arg(m_playerData.totalKills));
    
    // 🔄 如果连接断开或回到初始状态，取消长按操作和反向动画
    if ((m_isLongPressing || m_isReverseAnimating) && (!connected || isInitialState)) {
        addDebugMessage("取消长按和反向动画：连接断开或回到初始状态");
        if (m_isLongPressing) {
            cancelLongPress();
        }
        if (m_isReverseAnimating) {
            m_isReverseAnimating = false;
            m_reverseTimer->stop();
            m_longPressProgress = 0;
        }
    }
    
    if (m_startButton) {
        // 🔒 开始按钮逻辑：根据游戏状态显示不同功能（除非正在长按或反向动画中）
        if (!m_isLongPressing && !m_isReverseAnimating) {  // 长按或反向动画中不改变按钮文本和样式
            if (!connected) {
                m_startButton->setEnabled(false);
                m_startButton->setText("📡 等待连接...");
            } else if (isInitialState) {
                // 🏆 通关重置后或游戏刚开始：显示开始游戏按钮
                m_startButton->setEnabled(true);
                m_startButton->setText("🎮 开始游戏");
                addDebugMessage("按钮状态：初始状态，显示'开始游戏'");
            } else if (inCombat) {
                m_startButton->setEnabled(true);  // 战斗中可以重新开始（长按）
                m_startButton->setText("⏸️ 战斗中");
                addDebugMessage("按钮状态：自动战斗中，显示'战斗中'");
            } else if (inGame) {
                m_startButton->setEnabled(true);  // 游戏中可以重新开始（长按）
                m_startButton->setText("🔄 重新开始");
                addDebugMessage("按钮状态：游戏中，显示'重新开始'");
            } else {
                // 🎯 游戏结束但未重置的其他状态（等待中且有进度）
                m_startButton->setEnabled(true);
                m_startButton->setText("🔄 重新开始");
                addDebugMessage("按钮状态：其他状态，显示'重新开始'");
            }
        }
        
        // 显示长按提示（当可以重新开始时，且不在动画中）
        if (!m_isLongPressing && !m_isReverseAnimating) {
            if (connected && !isInitialState && (inGame || inCombat || m_playerData.level > 1 || m_playerData.totalKills > 0)) {
                m_startButton->setToolTip("💡 长按3秒重新开局");
            } else {
                m_startButton->setToolTip("点击开始新游戏");
            }
        }
    }
    
    // 🔒 收到升级响应，取消超时保护
    if (m_timeoutTimer && m_timeoutTimer->isActive()) {
        m_timeoutTimer->stop();
        addDebugMessage("收到升级响应，取消超时保护");
    }
    
    if (m_attackButton) {
        // 🔒 攻击按钮逻辑：只有在游戏中、不在自动战斗中、不在准备阶段、且不在倒计时阶段时可用
        bool canAttack = connected && inGame && !inCombat && !isPreparing;
        
        // 🔄 额外检查：如果有请求正在等待响应，禁用攻击按钮
        if (m_isStartRequestPending || m_isAttackRequestPending) {
            canAttack = false;
        }
        
        // 🔄 额外检查：如果玩家刚发送开始游戏请求，但还在等待服务器响应，也应该禁用攻击按钮
        // 通过检查按钮文本判断是否在准备阶段
        bool isPreparingGame = (m_startButton && (m_startButton->text().contains("准备中") || 
                                                 m_startButton->text().contains("准备游戏") ||
                                                 m_startButton->text().contains("重新开局中")));
        
        if (isPreparingGame) {
            canAttack = false;
        }
        
        m_attackButton->setEnabled(canAttack);
        
        if (!connected) {
            m_attackButton->setText("📡 等待连接...");
            m_attackButton->setProperty("state", "");
        } else if (isPreparing) {
            m_attackButton->setText("⏳ 准备下一关...");
            m_attackButton->setProperty("state", "preparing");
        } else if (m_isStartRequestPending) {
            m_attackButton->setText("⏳ 游戏准备中...");
            m_attackButton->setProperty("state", "preparing");
        } else if (m_isAttackRequestPending) {
            m_attackButton->setText("⚔️ 攻击处理中...");
            m_attackButton->setProperty("state", "preparing");
        } else if (isPreparingGame) {
            m_attackButton->setText("⏳ 游戏准备中...");
            m_attackButton->setProperty("state", "preparing");
        } else if (!inGame) {
            m_attackButton->setText("🎮 请先开始游戏");
            m_attackButton->setProperty("state", "");
        } else if (inCombat) {
            m_attackButton->setText("⏸️ 战斗中...");
            m_attackButton->setProperty("state", "fighting");
        } else {
            m_attackButton->setText("⚔️ 攻击");
            m_attackButton->setProperty("state", "ready");
        }
        m_attackButton->style()->unpolish(m_attackButton);
        m_attackButton->style()->polish(m_attackButton);
    }
    
    if (m_statusButton) {
        m_statusButton->setEnabled(connected);
    }
    
    if (m_helpButton) {
        m_helpButton->setEnabled(true);  // 帮助按钮始终可用
    }
}

// 🔒 安全机制：超时时重置按钮状态
void QClient::resetButtonsOnTimeout()
{
    // 检查连接状态，如果服务器无响应，重新启用按钮
    if (m_connectionState == ConnectionState::CONNECTED) {
        QMutexLocker locker(&m_playerDataMutex);
        
        // 如果不在自动战斗中，说明可能是服务器响应超时，重新启用按钮
        if (!m_playerData.isInAutoCombat) {
            addSystemMessage("⚠️ 服务器响应超时，按钮状态已重置");
            addSystemMessage("💡 如果操作未成功，请重试");
            
            // 🔒 清除所有请求标志
            m_isStartRequestPending = false;
            m_isAttackRequestPending = false;
            addDebugMessage("超时保护：清除所有请求标志");
            
            updateButtonStates();
        }
    }
}

// 🔄 长按重新开始功能实现
void QClient::startLongPress()
{
    // 只有在游戏中或战斗中才启用长按重新开始
    {
        QMutexLocker locker(&m_playerDataMutex);
        
        // 🏆 判断是否是初始状态（通关重置后或游戏刚开始）
        bool isInitialState = (m_playerData.gameState == GameState::WAITING && 
                              m_playerData.level == 1 && 
                              m_playerData.totalKills == 0);
        
        addDebugMessage(QString("startLongPress检查: gameState=%1, level=%2, totalKills=%3, isInitial=%4")
                       .arg(static_cast<int>(m_playerData.gameState)).arg(m_playerData.level)
                       .arg(m_playerData.totalKills).arg(isInitialState));
        
        if (isInitialState) {
            // 🏆 初始状态：不启用长按，应该使用普通点击开始游戏
            addDebugMessage("startLongPress: 检测到初始状态，不启用长按功能");
            return;
        }
        
        // 检查是否有游戏进度（在游戏中或有历史记录）
        bool hasProgress = (m_playerData.gameState == GameState::IN_COMBAT || 
                           m_playerData.level > 1 || 
                           m_playerData.totalKills > 0);
        
        if (!hasProgress) {
            addDebugMessage("startLongPress: 无游戏进度，不启用长按功能");
            return;
        }
    }
    
    addDebugMessage("开始长按重新开始检测");
    m_isLongPressing = true;
    m_longPressProgress = 0;
    
    // 启动长按计时器（3秒）
    m_longPressTimer->start(3000);
    
    // 启动进度更新计时器（每100ms更新一次）
    m_progressTimer->start(100);
    
    // 立即更新按钮显示
    updateLongPressProgress();
    
    addSystemMessage("🔄 检测到长按，正在准备重新开局...");
    addSystemMessage("⏱️ 继续按住3秒确认重新开始");
}

void QClient::cancelLongPress()
{
    if (!m_isLongPressing) {
        return;
    }
    
    addDebugMessage("取消长按重新开始，启动反向动画");
    m_isLongPressing = false;
    
    // 停止长按相关计时器
    m_longPressTimer->stop();
    m_progressTimer->stop();
    
    // 启动反向恢复动画
    m_isReverseAnimating = true;
    m_reverseTimer->start(50);  // 每50ms更新一次，比长按时更频繁，动画更流畅
    
    addSystemMessage("📋 重新开局操作已取消");
}

void QClient::updateLongPressProgress()
{
    if (!m_isLongPressing) {
        return;
    }
    
    // 更新进度（0-100）
    m_longPressProgress += 3;  // 每100ms增加3%，3秒达到100%
    
    if (m_longPressProgress > 100) {
        m_longPressProgress = 100;
    }
    
    // 更新按钮文本（不显示百分比，颜色变化已足够表达进度）
    if (m_startButton) {
        m_startButton->setText("🔄 长按重新开局");
        
        // 根据进度改变按钮颜色
        if (m_longPressProgress < 50) {
            m_startButton->setProperty("longPressState", "initial");
        } else if (m_longPressProgress < 90) {
            m_startButton->setProperty("longPressState", "middle");
        } else {
            m_startButton->setProperty("longPressState", "final");
        }
        m_startButton->style()->unpolish(m_startButton);
        m_startButton->style()->polish(m_startButton);
    }
    
    addDebugMessage(QString("长按进度: %1%").arg(m_longPressProgress));
}

void QClient::updateReverseProgress()
{
    if (!m_isReverseAnimating) {
        return;
    }
    
    // 反向减少进度，每50ms减少6%，约0.8秒完成反向动画
    m_longPressProgress -= 6;
    
    if (m_longPressProgress <= 0) {
        // 动画完成，恢复到初始状态
        m_longPressProgress = 0;
        m_isReverseAnimating = false;
        m_reverseTimer->stop();
        
        // 恢复按钮原始状态
        if (m_startButton) {
            m_startButton->setProperty("longPressState", "");
            m_startButton->style()->unpolish(m_startButton);
            m_startButton->style()->polish(m_startButton);
            
            // 更新按钮状态，需要加锁
            QMutexLocker locker(&m_playerDataMutex);
            updateButtonStates();
        }
        
        addDebugMessage("反向动画完成，按钮恢复原始状态");
        return;
    }
    
    // 根据当前进度设置颜色（与长按时相同的颜色逻辑）
    if (m_startButton) {
        if (m_longPressProgress < 50) {
            m_startButton->setProperty("longPressState", "initial");
        } else if (m_longPressProgress < 90) {
            m_startButton->setProperty("longPressState", "middle");
        } else {
            m_startButton->setProperty("longPressState", "final");
        }
        m_startButton->style()->unpolish(m_startButton);
        m_startButton->style()->polish(m_startButton);
    }
    
    addDebugMessage(QString("反向进度: %1%").arg(m_longPressProgress));
}

void QClient::executeLongPressAction()
{
    if (!m_isLongPressing) {
        return;
    }
    
    addDebugMessage("执行长按重新开局动作");
    
    // 停止进度更新
    m_progressTimer->stop();
    m_isLongPressing = false;
    
    addSystemMessage("✅ 长按确认！正在重新开局...");
    addSystemMessage("🔄 游戏数据将被重置");
    
    // 发送重新开局请求，等待服务器处理并返回新状态
    auto startPacket = std::make_shared<GamePacket>(PacketType::GAME_START, m_playerId);
    sendPacket(startPacket);
    
    addSystemMessage("📡 已发送重新开局请求到服务器");
    addSystemMessage("⏱️ 等待服务器确认和游戏数据...");
    
    // 暂时禁用按钮，等待服务器响应后再更新状态
    {
        QMutexLocker locker(&m_playerDataMutex);
        if (m_startButton) {
            // 恢复按钮原始状态
            m_startButton->setProperty("longPressState", "");
            m_startButton->style()->unpolish(m_startButton);
            m_startButton->style()->polish(m_startButton);
            m_startButton->setEnabled(false);
            m_startButton->setText("🔄 重新开局中...");
        }
        if (m_attackButton) {
            m_attackButton->setEnabled(false);
        }
    }
} 